home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / uud < prev    next >
Internet Message Format  |  1995-03-31  |  18KB
  1. From: Jan Brittenson <bson@rice-chex.ai.mit.edu>
  2. Subject:  v03i009:  uud - a uudecoder v1.0b, Part01/01
  3. Newsgroups: comp.sources.hp48
  4. Followup-To: comp.sys.hp48
  5. Approved: spell@seq.uncwil.edu
  6.  
  7. Checksum: 3800185134 (verify with brik -cv)
  8. Submitted-by: Jan Brittenson <bson@rice-chex.ai.mit.edu>
  9. Posting-number: Volume 3, Issue 9
  10. Archive-name: uud/part01
  11.  
  12.  
  13. BEGIN_DOC uud.doc
  14.    This is a beta version of UUD, an HP-48 uudecoder. It is considered
  15. a test version since any bugs may have rather disastrous effects, and
  16. although I've tried to test and debug it thoroughly, new problems may
  17. surface under unusual conditions. This means that if losing any data
  18. is unacceptible, then you should probably refrain from using this
  19. program until some time has passed with no bug reports, at which point
  20. I will repost it as a non-beta version.
  21.  
  22. UUD is relatively simple to use:
  23.  
  24.     UUD
  25.         Uudecode the string in level one, replacing
  26.         it with the resulting object.
  27.  
  28.             string --> obj
  29.  
  30.  
  31.    Any kermit preamble (the familiar "HPHP48-X" sequence) is ignored,
  32. so it can be used to uudecode objects built on a development system
  33. without bothering to generate the kermit preamble, as well as those in
  34. binary HP-48 kermit format. Any preamble is simply skipped.
  35.  
  36.    The total memory usage is the size of the string plus the size of
  37. the resultant object, plus ten nybbles. Since the size of a uuencoded
  38. file is about 1.6 times that of a binary file, the largest decodable
  39. string is approximately the available memory divided by 2.6. For 24kB
  40. of free memory, this means roughly 9.5kB. The string can reside
  41. anywhere, while the result will be allocated in TEMPOB.
  42.  
  43.    The binary and source code is provided "as is," under the GNU
  44. General Public License. For more details on this, see the source code
  45. included below. As I post this, I notice the code may need some
  46. browsing, which I will take care of once any bugs are fixed.
  47.  
  48. Happy hacking!
  49.  
  50.                         -- Jan Brittenson
  51.                            bson@ai.mit.edu
  52.  
  53. END_DOC
  54.  
  55. UUD
  56. Size: 346 bytes
  57. Xsum: #7f25h
  58.  
  59. uuencoded:
  60.  
  61. BYTES: #7F25h 353.5
  62.  
  63. BEGIN_UU uud.uue
  64. begin 644 uud
  65. M2%!(4#0X+5B=+2#[& U T-D"S"V@$0 "08._>0:H"!0#810D&/A(&/G0UC?D
  66. M  "XRA%&49J38F5G:6Z2&;(A,!2H ZWXTF> G>P& G<6!'XWD9;7+>K)AH&O
  67. M&9#Z$ !7'A<>UQV7'5-(4$A2&:8A$)$8^/H!.80   $H< A!)0)G#6GI@:$?
  68. MT:*>K*P8^A"%;5N/+WT&^"EE, 2L ZW8R6[ FV&BC/%=!2,RP,%A(S+ W )4
  69. M 8 ?9 8!$'1^<10T086_>09!%U,Q$$9!AH&OA)$O?6%T5G ID)8?ZAF0 1QS
  70. M,16P)P<W \6-/10%0:Y>8<%/%A,@:T$,$S_@%C#8IXQQ($ -8<%?\Y1^#E  
  71. M8<%?\W0=I!,-:0(PH9 F !#Z<&)P7G!:<%8@A!48^H'LM("A#X@4&&J1:DXQ
  72. G&&J0:$$1%1 'P%$!<0 -#8WHN0)7^+4)LP]ZI$=G\N"&,"LQL!(#
  73.  
  74. end
  75. END_UU
  76.  
  77.  
  78. ASC encoded:
  79.  
  80. BEGIN_ASC uud.asc
  81. %%HP: T(1)A(D)F(.);
  82. "D9D202BF81D0040D9D20CCD20A1100201438FB97608A804130164142818F8481
  83. 9F0D6D734E00008BAC116415A93926567696E629912B1203418A30DA8F2D7608
  84. D9CE6020776140E77319697DD2AE9C6818FA9109AF010075E171E17DD179D135
  85. 84058425916A120119818FAF10934800001082078014522076D0969E181AF11D
  86. 2AE9CACA81AF0158D6B5F8F2D7608F92560340CA30DA8D9CE60CB9162AC81FD5
  87. 5032230C1C1632230CCD20451008F14660100147E71741431458FB9760147135
  88. 130164146818FA4819F2D716476507920969F1AE910910C13713510B72707330
  89. 5CD8D3415014EAE5161CF4613102B614C031F30E61038D7AC8170204D0161CF5
  90. 3F49E7E00500161CF53F47D14A31D09620031A09620001AF072607E507A50765
  91. 02485181AF18CE4B081AF0884181A619A6E41381A6098614115101700C151017
  92. 00D0D0D88E9B20758F5B903BF0A74A74762F0E6803B2130B213052F7"
  93. END_ASC
  94.  
  95.  O  /
  96.   \/
  97.   /\  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  98.  O  \
  99.  
  100. BEGIN_SRC uud.star
  101. ;; uud.star -- HP-48 uudecoder
  102.  
  103. ;;    UUD is not distributed by the Free Software Foundation. Do not
  104. ;; ask them for a copy or how to obtain new releases. Instead, send
  105. ;; e-mail to the address below. UUD is merely covered by the GNU
  106. ;; General Public License.
  107. ;;
  108. ;;    Please send your comments, ideas, and bug reports to
  109. ;; Jan Brittenson <bson@gnu.ai.mit.edu>
  110.  
  111.  
  112. ;;    Copyright (C) 1991 Jan Brittenson
  113. ;;
  114. ;;    UUD is free software; you can redistribute it and/or modify it
  115. ;; under the terms of the GNU General Public License as published by
  116. ;; the Free Software Foundation; either version 1, or (at your option)
  117. ;; any later version.
  118. ;;
  119. ;;    UUD is distributed in the hope that it will be useful, but
  120. ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  121. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  122. ;; General Public License for more details.
  123. ;;
  124. ;;    This program is distributed without a copy of the GNU General
  125. ;; Public License; to obtain a copy, write to the Free Software
  126. ;; Foundation, 675 Mass Ave, Cambridge, MA 02139, USA, or send e-mail
  127. ;; to bson@gnu.ai.mit.edu.
  128.  
  129.  
  130. ;;    UUD is written in STAR assembler. The command line below
  131. ;; exemplifies how to build it:
  132. ;;
  133. ;;    star -j uud uud hp48 stdsyms uud
  134. ;;
  135. ;;    The file hp48.star, which contains macro definitions specific to
  136. ;; the HP-48, is included with the STAR distribution, obtainable by
  137. ;; anonymous FTP from ftp.ai.mit.edu, in pub/star-1.04.4.tar.Z. The
  138. ;; file stdsyms.star is a file containing entry point definitions for
  139. ;; the HP-48, although UUD does not rely heavily on ROM calls.
  140. ;;
  141. ;; Jan Brittenson
  142. ;; Boston, 25 November 1991
  143.  
  144.  
  145. ; Bugs/problems
  146. ;
  147. ; The file name is not extracted from the uu string. It could be
  148. ; returned in level 1 with the result in level 2 for easy storage.
  149. ; How often is the file name of interest? I don't know, since there
  150. ; hasn't been a uudecoder for the HP-48 out there yet. Things should
  151. ; become more clear once UUD has been in use for a while.
  152.  
  153.  
  154.     radix    0x10
  155.     header    `x'
  156.  
  157. ;; UUD
  158. ;;
  159. ;; In:
  160. ;;   1: uu.string
  161. ;;
  162. ;; Out:
  163. ;;   1: result.any
  164.  
  165.     rpl
  166.     Prg                ; PRG
  167.       Switch_on_argtype        ;    Switch on argument type
  168.       Short_3            ;    STR
  169.       Prg                ;    PRG
  170.     endrpl
  171.  
  172. ; Verify string format and calculate resulting size.
  173. ; 
  174. ; In:
  175. ;    1: uu.string
  176. ;
  177. ;
  178. ; Out (if valid string)        (if invalid)
  179. ;    3: uu.string        2: uu.string
  180. ;    2: size.short        1: @#3a81
  181. ;    1: @#3ac0
  182. ;
  183.  
  184.     code
  185.  
  186. ; Get uu.string
  187.  
  188.     clr    p
  189.     move.a    @d1, a
  190.     call    save_regs        ; Save system registers
  191.     brz.a    a, $1077        ; End of stack - fail
  192.  
  193. ; Verify string is at least 14 characters
  194.  
  195.     move    a, d0
  196.     add    5, d0            ; D0 = &string size
  197.     move.a    @d0, a
  198.     sub.a    5, a
  199.     srb.a    a
  200.     move.a    a, c
  201.     move.a    c, d            ; D.A = string size, in bytes
  202.     move.p5    ^d14, c
  203.     brge.a    c, a, $1077        ; Too short - ignore request
  204.  
  205. ; Verify string starts with `begin'
  206.  
  207.     add    5, d0            ; D0 = &line 1
  208.     move.10    @d0, a
  209.     move.p10 `begin', c
  210.     move    9, p
  211.     breq.wp    c, a, $1001         ; Yup `begin' - sum up size
  212.  
  213. ; Fail
  214.  
  215. $1077:
  216.     clr    p
  217.     move.p5    true, c
  218.     move.a    c, a
  219.     call    restore_regs
  220.     jump    pushobj_a_rplret    ; Push @#3ac1 and continue
  221.  
  222.  
  223. ; D0 points to string data - sum up reulting string size. D.A contains
  224. ; the size of the remainer. R1.A holds the sum. Also decode the first
  225. ; 24 bits and see if they are `HPHP48-' - if so, adjust size by 16 nybbles.
  226.  
  227. $1001:
  228.     clr    p
  229.     call    next_record        ; Advance to first line
  230.     brcs    $1077            ; Uh... end of string?
  231.     call    decode_char        ; Decode record size
  232.     brz.b    b, $1077        ; Null file - no can do, man!
  233.     
  234.     clr.a    c
  235.     move.b    b, c            ; C.A = record size
  236.     slb.a    c            ; In nybbles
  237.     sub.a    ^d10, c            ; Less 10
  238.     move    c, r1            ; R1.A = first record size - 10
  239.  
  240.     clr.w    a
  241.     move    a, r0            ; Assume no inhibition count
  242.     call    uud_incrchar        ; 6 bits
  243.     call    uud_incrchar        ; 12 bits
  244.     call    uud_incrchar        ; 18 bits
  245.     call    uud_incrchar        ; 24 bits
  246.  
  247.     move.p6    `HPH', c        ; Really only need to check first
  248.                     ; 3 bytes, since "HPH" is not a
  249.                     ; valid prologue.
  250.     move    5, p
  251.     brne.wp    c, a, $1102        ; Nope preamble - ignore
  252.  
  253.     clr    p
  254.     move    r1, c
  255.     sub.a    ^d16, c            ; Reduce size by 16
  256.     move    c, r1
  257.     move.p5    ^d8, c            ; Preamble size 8 bytes
  258.     move    c, r0
  259. $1102:
  260.     clr    p
  261. $1100:
  262.     call    next_record        ; Advance to next line
  263.     brcs    $10770            ; Uh... end of string?
  264.  
  265.     clr    p
  266.     call    decode_char        ; B.B = uud(@D0+)
  267.     brz.b    b, $1109        ; Last record - done
  268.  
  269.     move.a    r1, a            ; A.A = sum
  270.     clr.a    c
  271.     move.b    b, c            ; C.A = record size
  272.     add.a    c, a            ; A.A = new sum
  273.     add.a    c, a            ; ...in nybbles
  274.     move.a    a, r1            ; R0.A = new sum
  275.     brcc    $1100            ; Loop
  276.  
  277. $10770:
  278.     jump    $1077
  279.  
  280. ; Successful completion. Push size in R0.A, @#3ac0 and continue.
  281.  
  282. $1109:
  283.     call    restore_regs        ; Restore RPL registers
  284.     call    pushshort_r0r1        ; Push preamble and result 
  285.                     ; size as shorts
  286.     move.p5    false, c
  287.     move.a    c, a
  288.     jump    pushobj_a_rplret    ; Push @#3ac0 and continue
  289.  
  290.     endcode
  291.  
  292.  
  293. ; Allocate target
  294.  
  295.     rpl
  296.          If_true_then
  297.            Error_bad_arg_value
  298.          Nullstring, Swap, Realloc, Swap
  299.     endrpl
  300.  
  301.  
  302. ; Decode object
  303. ;
  304. ; In:
  305. ;   3: uu.string
  306. ;   2: result.string        (in TEMPOB)
  307. ;   1: preamble-size.short
  308. ;
  309. ; Out:
  310. ;   1: result.any
  311. ;
  312.  
  313.     code
  314.  
  315.     call    getshort        ; A.A = preamble size
  316.     move    a, r0            ; R0.A = preamble size
  317.  
  318.     move.a    @d1, c            ; C.A = &result area
  319.     inc.a    d
  320.     add    5, d1
  321.  
  322.     move.a    @d1, a            ; A.A = &uu.string
  323.     move.a    c, @d1            ; Replace with result
  324.  
  325.     call    save_regs        ; Save RPL registers
  326.     move.a    @d1, c            ; C.A = &result area
  327.  
  328.     move    c, d1            ; D1 = &result area
  329.     move    a, d0            ; D0 = &uu.string
  330.     add    5, d0
  331.     move.a    @d0, c            ; C.A = uu.string size, in nybbles
  332.     sub.a    5, c
  333.     srb.a    c            ; (size-5)/2
  334.     move.a    c, d            ; D.A = uu.string size, in bytes
  335.     add    5, d0            ; Advance D0 to uu.string data
  336.  
  337.     call    next_record        ; Advance D0 to next record
  338.  
  339.  
  340. ; Main uudecode loop. At this point:
  341. ;
  342. ;  D0 = address of first record
  343. ;  D1 = address of string object (to be overwritten)
  344. ;  D.A= string character count
  345. ;  R0.A= # of bytes of prologue to skip
  346.  
  347. uud_main:
  348.     call    decode_char        ; B.B = size (0-63) from @D0+
  349.     brz.b    b, uud_finish        ; Null record - done, skip rest
  350.     move.b    b, c
  351.     move    c, r1            ; R1.A = Store limit
  352.     move    c, r4            ; R4.B = record byte count
  353.     swap    c, d1
  354.     move    c, d1
  355.     move    c, r3            ; R3.A = original destination address
  356.     call    decode_record        ; Decode record, @D0+ --> @D1+
  357.  
  358. ; Advance D0 to next record and loop
  359.  
  360.     call    next_record
  361.     brcc    uud_main        ; Decode next record
  362.  
  363.  
  364. ; We're done processing. Simply return, since the result object replaces
  365. ; the uu.string object.
  366.  
  367. uud_finish:
  368.     jump    rr_rplcont
  369.  
  370.  
  371. ;;
  372. ;; Decode character.
  373. ;; In:
  374. ;;    D0 = address of character
  375. ;;    D.A= characters left in string
  376. ;;
  377. ;; Out:
  378. ;;    B.B= 6-bit character code
  379. ;;    D.A= decremented, exit if zero
  380. ;;    Carry= clear
  381. ;;
  382. ;; Used:
  383. ;;    C.B
  384. ;;
  385.  
  386. decode_char:
  387.     move.b    @d0, c    
  388.     move.b    c, b            ; B.B = next character
  389.     add    2, d0            ; Advance to next character
  390.     dec.a    d
  391.     brcs    uud_error        ; Nothing left - error
  392.     move.p2    ` ', c            ; Offset
  393.     sub.b    c, b            ; Subtract offset
  394.     brcs    uud_error        ; Unprintable - error
  395.     move.p2    077, c
  396.     and.b    c, b            ; Clear bits 6 and 7 of character
  397.     retclrc
  398.  
  399.  
  400. ; Error, bad string
  401.  
  402. uud_error:
  403.     jump    Error_bad_arg_value+5
  404.  
  405.  
  406. ;;
  407. ;; Advance to beginning of next record. First advance to CR/LF,
  408. ;; then advance until non-CR/LF.
  409. ;; In:
  410. ;;    D0 = character pointer
  411. ;;    D.A= characters left in string
  412. ;;
  413. ;; Out:
  414. ;;    D0 = address of first char of next record
  415. ;;    D.A= characters left in string
  416. ;;    Carry = clear
  417. ;;
  418. ;; Used:
  419. ;;    C.B, A.B
  420. ;;
  421.  
  422. next_record:
  423. $2:
  424.     call    crlf_p            ; Do we have CR or LF?
  425.     brcs    $1            ; Yes - go skip CR and LFs
  426.     add    2, d0            ; Advance to next char
  427.     dec.a    d            ; One char less in string
  428.     brcc    $2
  429.     brcs    uud_error        ; Premature end of string
  430. $1:
  431.     call    crlf_p            ; Do we have CR or LF?
  432.     retcc                ; No - return
  433.     add    2, d0            ; Skip it
  434.     dec.a    d            ; One char less in string
  435.     brcc    $1
  436.     brcs    uud_error        ; Premature end of string
  437.  
  438.  
  439. ; Test if character @D0 is CR or LF
  440.  
  441. crlf_p:
  442.     move.b    @d0, a
  443.     move.p2    CR, c
  444.     reteq.b    c, a            ; Return with carry set if CR
  445.     move.p2    LF, c
  446.     reteq.b    c, a            ; Return with carry set if LF
  447.     ret                ; Otherwise, return with carry clear
  448.  
  449.  
  450. ;;
  451. ;; Decode record.
  452. ;; In:
  453. ;;     D0  = address of first char in record
  454. ;;    D1  = address of destination byte buffer
  455. ;;    D.A = number of characters left in string
  456. ;;    R0.A= number of bytes of prologue to skip
  457. ;;    R1.A= number of bytes to really decode
  458. ;;
  459. ;; Out:
  460. ;;    D0  = address of first char following record (CR/LF)
  461. ;;    D1  = address of first byte following the last one added (including
  462. ;;          pad bytes)
  463. ;;    D.A = number of characters left in string, adjusted
  464. ;;    Carry = clear
  465. ;;
  466. ;; Used:
  467. ;;    A, B, C
  468. ;;
  469.  
  470. decode_record:
  471.     clr.w    a
  472.     call    uud_incrchar        ; 6 bits
  473.     call    uud_incrchar        ; 12 bits
  474.     call    uud_incrchar        ; 18 bits
  475.     call    uud_incrchar        ; 24 bits
  476.  
  477. ; At this point, the 3 bytes are in A.6, in reverse order, i.e.
  478. ; the third byte is in A.B.
  479.  
  480.     move    4, p            ; Nybbles 4,5 is byte 1
  481. $1:
  482.     setb    1, st
  483.     move.a    r0, c
  484.     dec.a    c            ; One less preamble byte to go
  485.     brcs    $101
  486.     move.a    c, r0
  487.     clrb    1, st
  488. $101:
  489.     move.b    r1, c
  490.     dec.b    c            ; One less byte to copy
  491.     brcs    $171            ; End of copy - return
  492.     move.b    c, r1
  493.     brbc    1, st, $71
  494. $102:
  495.     move.p    a, @d1            ; Add low nybble of byte
  496.     inc    d1
  497.     inc    p
  498.     move.p    a, @d1            ; Add high nybble of byte
  499.     inc    d1
  500.     dec    p            ; Move P to low nyb of next byte
  501. $71:
  502.     dec    p
  503.     dec    p
  504.     brne    p, ^d14, $1        ; Loop bytes until P wraps
  505.  
  506.     clr    p
  507.     call    crlf_p            ; CR or LF?
  508.     brcc    decode_record        ; No - decode another 24 bits
  509. $171:
  510.     retclrc
  511.  
  512. ; Add 6 bits of uu-encoded data to the 6 low-order bits of A.W
  513.  
  514. uud_incrchar:
  515.     sln.w    a            ; Shift A left 6 bits
  516.     slb.w    a
  517.     slb.w    a
  518.  
  519.     call    decode_char        ; Get 6 bits of data in B.B
  520.     or.b    b, a            ; Add to A
  521.     retclrc
  522.  
  523.     even
  524.  
  525.     endcode
  526.  
  527.  
  528. ; Tail end of RPL program object
  529.  
  530.     rpl
  531.        EndObj            ;    PRG
  532.     EndObj                ; PRG
  533.     endrpl
  534.  
  535. END_SRC
  536.  
  537.  O  /
  538.   \/
  539.   /\  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  540.  O  \
  541.  
  542. BEGIN_SRC stdsyms.star
  543. ;; stdsyms.star -- Common Symbols
  544. ;;
  545. ;; This file is in the public domain. Please notice that
  546. ;; uud.star is not.
  547. ;;
  548. ;; Jan Brittenson
  549. ;; Boston, 25 November 1991
  550. ;;
  551.  
  552.  
  553.     nlistblock
  554.  
  555.     radix    0x10
  556.  
  557. GROB_null = 505b2
  558. OpenIO = 2eb37
  559. CloseIO = 315c6
  560. Freeze = 142fb
  561. Cllcd = 5046a
  562. Eval_prev_context = 6fd1
  563. Push_next = 6e97
  564. Char_000 = 6541e
  565. Add_string_char = 52ee
  566. Add5 = 6258a
  567. Inc = 3def
  568. Dup_Inc = 628eb
  569. Short_200h = 64f0e
  570. Short_100h = 64e32
  571. Short_60h = 64c8e
  572. Short_c0h = 64dd8
  573. Short_bbh = 64dce
  574. Short_31h = 64b44
  575. String_to_grob_pitch8 = 11d00
  576. Nullstring = 55df
  577. Nullstring_copy = 1613f
  578. Program_null = 40788
  579. Realloc = 61c1c
  580. Num = 1410f
  581. Add = 3dbc
  582. Add_string_string = 5193
  583. LeftLess1_string_short = 63259
  584. ArrayTo_array = 1d0ab
  585. ArrayTo = 1d0ab
  586. Dec = 3e0e
  587. Dup = 3188
  588. EndObj = 312b
  589. Equalp = 3d19
  590. Nonzerop = 3cc7
  591. No_args = 18a15
  592. Zerop = 3ca6
  593. Dup_Zerop = 62266
  594. Get_2Lastlocal = 613e7
  595. Get_3lastlocal = 6140e
  596. Get_4lastlocal = 61438
  597. Get_lastlocal = 613b6
  598. If_then_else = 61ad8
  599. If_true_then = 619bc
  600. If_not_true_then = 712a
  601. ;If_true_then = 619ad
  602. Dup_If_zero_then_exec = 618a8
  603. If_User_flag_then_else = 63ed9
  604. Pview_short_short = 4f052
  605. Listob = 2a74
  606. ListAlgPrgTo = 54af
  607. ListTo = 54af
  608. ListTo_StoreLocals = 74d0
  609. Local_M = 0xe4c1
  610. Local_N = 0xe4ae
  611. Local_S = 41bea
  612. Mul = 3ec2
  613. Mul2 = 3e6f
  614. Mul_array_real = 362dc
  615. Next = 7334
  616. Prg = 2d9d
  617. True = 3a81
  618. False = 3ac0
  619. Bin_to_short = 5a03
  620. Two_Bins_to_shorts = 4f3d1
  621. Real_to_short = 18cea
  622. Real_to_short_Swap = 62e7b
  623. Swap_Over = 61380
  624. Roll = 3325
  625. Drop = 3244
  626. Swap_Drop = 60f9b
  627. Drop2 = 3258
  628. Xlib_to_Rpl = 7e99
  629. Error_Bad_arg_type = 18cb2
  630. Short_0bh = 405d
  631. Clear_lastargs = 4d33
  632. Reset_lastargs = 53842
  633. Need_2_args = 18a8d
  634. Need_4_args = 18b9f
  635. SL_Need_1_arg = 18aa5
  636. Switch_on_argtype = 18fb2
  637. SL_Switch_2_argtypes = 18edf
  638. SL_Switch_on_argtype = 18ece
  639. SL_Switch_4_argtypes = 18f01
  640. SaveLast_Need_1_arg = 18aa5
  641. Lastkey = 4714
  642. Short_0 = 3fef
  643. Short_1 = 3ff9
  644. Short_2 = 4003
  645. Short_3 = 400d
  646. Short_4 = 4017
  647. Short_5 = 4021
  648. Short_8 = 403f
  649. Short_0dh = 4071
  650. Short_0fh = 4085
  651. Short_10h = 408f
  652. Short_16h = 40cb
  653. Short_1fh = 4125
  654. Short_20h = 412f
  655. Short_21h = 4139
  656. Short_40h = 64bda
  657. Short_7fh = 1cd16
  658. Short_83h = 64d24
  659. Pdim = 4b323
  660. Equal2p = 6229a
  661. Real_1 = 2a2c9
  662. Real_2 = 2a2de
  663. Real_3 = 2a2f3
  664. Real_4 = 2a308
  665. Real_5 = 2a31d
  666. Real_7 = 2a347
  667. Short_to_real = 18dbf
  668. Start_1_to_N = 73db
  669. Store_2lastlocal = 615f0
  670. Store_3lastlocal = 61600
  671. Store_4lastlocal = 61610
  672. Store_lastlocal = 615e0
  673. Store_local = 61625
  674. Swap = 3223
  675. Array_dims = 35a9
  676. ToArray_real = 1d02c
  677. ToArray_list = 1d040
  678. Size_list = 567b
  679. ToList = 5459
  680. ToList2 = 631b9
  681. TwoShorts_to_reals = 1950b
  682. TwoReals_to_shorts = 194f7
  683. Short_to_bin = 59cc
  684. Swap_Over = 61380
  685. Over = 32c2
  686. Rot = 3295
  687. Rolld3 = 60fac
  688. Rolld4 = 6109e
  689. Div2 = 3e8e
  690. Div = 3ef7
  691. Disp_any_real = 140ab
  692. Disp_pitch8Str_line0 = 1245b
  693. Disp_pitch8Str_line1 = 1246b
  694. Disp_pitch8str_line2 = 1247b
  695. Disp_pitch8str_line3 = 1248b
  696. Disp_pitch8str_line4 = 1249b
  697. Disp_pitch8str_line5 = 124ab
  698. Disp_pitch8str_line6 = 124bb
  699. Disp_pitch8str_line7 = 124cb
  700.  
  701. Loop = 71a2
  702. Exit_loop = 71e5
  703. Until = 71c8
  704. Next = 7334
  705. If_ATTN_then_FlushKbd_Kill = 4243e
  706. If_ATTN_then_End = 4245c
  707. Pr1 = 318fe
  708. Error_bad_arg_value = 18ca2
  709. If_not_equal_then_short = 6336c
  710.  
  711. ;; ML routines
  712.  
  713. getshort = 6641
  714. get2shorts = 3f5d
  715. pushshort_r0r1 = 6529
  716. pushshort_r0 = 6537
  717. pushshort_r0_rplret= 18d0a
  718. pushobj_a = 54266
  719. pushobj_a_rplret = 6ec9
  720. stralloc_nibbles = 5b7d
  721. blkcopy = 670c
  722. save_regs = 679b
  723. restore_regs = 67d2
  724. rplcont = 71be
  725. rr_rplcont = 5143
  726. kbflush = 0xd57
  727. keybuf = 704ea
  728. indicate_not_busy = 42359
  729. int_mask = 10e
  730. uart_xmit = 116
  731. adjust_parity = 3113d
  732. uart_xmit_rdy_p = 310ca
  733. recv_getc = 31289
  734.  
  735. ATTN_p = 4988
  736. clear_ATTN = 0xd8e
  737.  
  738. graph_grob_ptr = 70565
  739. stack_grob_ptr = 70556
  740.  
  741. Copyright = ch^^d169
  742. Beta = ch^^d223
  743. CR = ch^015
  744. LF = ch^012
  745. END_SRC
  746.                         -- Jan Brittenson
  747.                            bson@ai.mit.edu
  748.  
  749.